home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 2 / LSD and 17bit Compendium Deluxe - Volume II.iso / a / prog / asmsrc / thesource-7.lha / Source / DefFunc.lha / DefFunc / dfctree.c < prev    next >
C/C++ Source or Header  |  1993-12-14  |  4KB  |  200 lines
  1. /*********************************************************
  2.  *
  3.  *    Copyright (c) 1993  Ke Jin
  4.  *
  5.  *    Permission to use, copy, modify, and distribute
  6.  *    this software and its documentation without fee
  7.  *    is granted, provided that the author's name and
  8.  *    this copyright notice are retained.
  9.  *
  10.  * -----------------------------------------------------
  11.  *
  12.  *    dfctree.c -- defunc low level module
  13.  *
  14.  *    public  function : exparse();
  15.  *                       evaluate();
  16.  *                       reduce();
  17.  *     
  18.  *********************************************************/
  19.  
  20. #include <stdio.h>
  21. #include "dfctree.h"
  22.  
  23. #ifdef __cplusplus
  24.   extern "C" {    /* for c++ */
  25. #endif
  26.  
  27. #if NeedFunctionPrototypes
  28.   extern yyinit(char* expression);
  29.   extern int yyparse(void);
  30. #else
  31.   extern yyinit();
  32.   extern int yyparse();
  33. #endif
  34.  
  35. #define ltree  reduce(tree+tree->left-i,  tree->left)
  36. #define rtree  reduce(tree+tree->right-i, tree->right)
  37. #define trval  tree->content.value
  38. #define ltrval ltree->content.value
  39. #define rtrval rtree->content.value
  40.  
  41. #if NeedFunctionPrototypes
  42.   Node* reduce(Node* tree, int i)
  43. #else
  44.   Node* reduce(tree, i)
  45.   Node* tree;
  46.   int   i;
  47. #endif
  48. /* constant folding. i is the shift relative to root 
  49.  * reduce tree still in original memory address. the
  50.  * root of the tree be returned */
  51. { 
  52.     if(tree == 0) return 0;
  53.  
  54.     switch(tree->type)
  55.     {
  56.     case const_node:
  57.     case arg_node:
  58.              break;
  59.  
  60.     case simplex_fnct_node:
  61.          if(rtree->type==const_node)
  62.          {
  63.          tree->type = const_node;
  64.          trval = (tree->content.fnctptr)(rtrval);
  65.              }
  66.          break;
  67.  
  68.         case duplex_fnct_node:
  69.          if((ltree->type==const_node)&&(rtree->type==const_node))
  70.          {
  71.          tree->type = const_node;
  72.          trval = (tree->content.fnctptr)(ltrval, rtrval);
  73.              }
  74.          break;
  75.  
  76.         case unary_op_node:
  77.           if(rtree->type==const_node)
  78.          {
  79.           tree->type = const_node;
  80.          switch(tree->content.op)
  81.          {
  82.              case op_neg: trval = -rtrval; break;
  83.  
  84.              default: break;
  85.                  }
  86.              }
  87.          break;
  88.  
  89.         case binary_op_node:
  90.          if(rtree->type==const_node&&tree->content.op==op_div)
  91.          {
  92.          tree->content.op=op_mul;
  93.          rtree->content.value = 1.0/(rtree->content.value);
  94.              }
  95.  
  96.          if(ltree->type==const_node&&rtree->type==const_node)
  97.          {
  98.          tree->type = const_node;
  99.          switch(tree->content.op)
  100.          {
  101.              case op_sum: trval = ltrval+rtrval; break;
  102.              case op_sub: trval = ltrval-rtrval; break;
  103.              case op_mul: trval = ltrval*rtrval; break;
  104.              case op_div: trval = ltrval/rtrval; break; 
  105.  
  106.              default: break;
  107.                  }
  108.              }
  109.              break;
  110.  
  111.         default: break;
  112.     }  
  113.  
  114.     return tree;
  115. }; 
  116.  
  117. #if NeedFunctionPrototype
  118.   int exparse(char* expression)
  119. #else
  120.   int exparse(expression)
  121.   char* expression;
  122. #endif
  123. {
  124.     yyinit(expression);  /* initial the parser */
  125.  
  126.     return yyparse();    /* on success, return 0 or tree size
  127.               * on error  , return -1 */
  128. };
  129.  
  130. #define lval evaluate(tree+tree->left-i,  tree->left , x, y)
  131. #define rval evaluate(tree+tree->right-i, tree->right, x, y) 
  132.  
  133. #if NeedFunctionPrototype
  134.   double evaluate(Node* tree, int i, double x, double y)
  135. #else
  136.   double evaluate(tree, i, x, y) 
  137.   Node*  tree;
  138.   int    i;
  139.   double x, y;
  140. #endif
  141. /* evaluate a parse tree. i is the shift relative to root */
  142. {
  143.     if(tree == 0) 
  144.     {
  145.     fprintf(stderr, "Null parse tree\n");
  146.         exit(1) ;
  147.     }
  148.  
  149.     switch (tree->type) 
  150.     {
  151.     case const_node:
  152.          return tree->content.value;
  153.  
  154.         case arg_node:
  155.          switch(tree->content.argidx)
  156.          {
  157.          case 1: return x;
  158.          case 2: return y;
  159.          default: exit(1);
  160.              }
  161.          break;
  162.  
  163.     case simplex_fnct_node:
  164.          return (tree->content.fnctptr)(rval);
  165.  
  166.         case duplex_fnct_node:
  167.          return (tree->content.fnctptr)(lval, rval);
  168.  
  169.         case unary_op_node:
  170.          switch(tree->content.op)
  171.          {
  172.         case op_neg: return -rval;
  173.  
  174.         default: break;
  175.              }
  176.          break;
  177.  
  178.         case binary_op_node:
  179.              switch(tree->content.op)
  180.          {
  181.         case op_sum: return lval + rval; 
  182.                 case op_sub: return lval - rval;
  183.         case op_mul: return lval * rval;
  184.         case op_div: return lval / rval;
  185.  
  186.         default: break;
  187.              }
  188.          break;
  189.  
  190.         default:
  191.          exit(1) ;   /* something wrong */
  192.     }
  193.  
  194.     return 0; /* turn off the warning of lint */
  195. };
  196.  
  197. #ifdef __cplusplus
  198.   }    /* end for c++ */
  199. #endif
  200.